/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Test;

import ImagenesDBGad.IO.Objeto;
import ImagenesDBGad.IO.Punto;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.apache.batik.dom.svg.SVGOMPathElement;

/**
 * @author NiCo
 */
public class UtilidadesDistancia {

//    final double area = 200;
//    final double distanciaMinEntrePuntos = 5;
    final static int giroRotacion = 5;

    /**
     * @deprecated no va?
     * @param path
     * @return
     */
    public static Objeto estandarizarImagenes(SVGOMPathElement path) {
        Objeto calculado = calcularPuntos(path);
        Objeto rotado = rotarImagen(calculado);
        return rotado;
    }

    /**
     * @deprecated @param pathElement
     * @return
     */
    private static Objeto calcularPuntos(SVGOMPathElement pathElement) {
        ArrayList<Punto> calculados = new ArrayList<Punto>();
        Objeto objeto = new Objeto();
        int puntos = Math.round(5 * pathElement.getTotalLength() / 100);
        float acumulado = 0;
        float incremento = pathElement.getTotalLength() / puntos;

        objeto.setV1x(pathElement.getBBox().getX());
        objeto.setV1y(pathElement.getBBox().getY());
        objeto.setV2x(pathElement.getBBox().getX() + pathElement.getBBox().getWidth());
        objeto.setV2y(pathElement.getBBox().getY() + pathElement.getBBox().getHeight());

        for (int i = 0; i < puntos; i++) {
            Punto pto = new Punto();
            pto.setX(pathElement.getPointAtLength(acumulado).getX());
            pto.setY(pathElement.getPointAtLength(acumulado).getY());
            acumulado = acumulado + incremento;
            calculados.add(pto);
        }

        objeto.setPuntos(calculados);

        return objeto;
    }

    /**
     * @deprecated no va?
     * @param objeto
     * @return
     */
    private static Objeto rotarImagen(Objeto objeto) {
        float relacionV = (objeto.getV2y() - objeto.getV1y()) / (objeto.getV2x() - objeto.getV1x());
        float xmv = objeto.getV1x();
        float ymv = objeto.getV1y();
        float xMv = objeto.getV2x();
        float yMv = objeto.getV2y();
        float xcv = ((objeto.getV2x() - objeto.getV1x()) / 2) + objeto.getV1x();
        float ycv = ((objeto.getV2y() - objeto.getV1y()) / 2) + objeto.getV1y();

        ArrayList<Punto> puntosN = new ArrayList<Punto>();
        float relacionN = 0;
        float xmn = Float.MAX_VALUE;
        float ymn = Float.MAX_VALUE;
        float xMn = Float.MIN_VALUE;
        float yMn = Float.MIN_VALUE;
        float xcn;
        float ycn;

        int grados = giroRotacion;
        while (relacionV > relacionN || grados <= 180) {
            puntosN.clear();
            relacionN = 0;
            xmn = Float.MAX_VALUE;
            ymn = Float.MAX_VALUE;
            xMn = Float.MIN_VALUE;
            yMn = Float.MIN_VALUE;
            xcn = 0;
            ycn = 0;
            for (Iterator<Punto> it = objeto.getPuntos().iterator(); it.hasNext();) {
                Punto pto = it.next();
                Punto ptoN = new Punto();
                ptoN.setX(xcv + (pto.getX() - xcv) * Math.cos(grados) - (pto.getY() - ycv) * Math.sin(grados));
                ptoN.setY(ycv + (pto.getX() - xcv) * Math.sin(grados) + (pto.getY() - ycv) * Math.cos(grados));
                puntosN.add(ptoN);

                if (ptoN.getX() < xmn) {
                    xmn = (float) ptoN.getX();
                }
                if (ptoN.getX() > xMn) {
                    xMn = (float) ptoN.getX();
                }
                if (ptoN.getY() < ymn) {
                    ymn = (float) ptoN.getY();
                }
                if (ptoN.getY() > yMn) {
                    yMn = (float) ptoN.getY();
                }
            }
            xcn = xmn + (xMn - xmn) / 2;
            ycn = ymn + (yMn - ymn) / 2;
            relacionN = (yMn - ymn) / (xMn - xmn);

            if (relacionN > relacionV) {
                relacionV = relacionN;
                xmv = xmn;
                xMv = xMn;
                ymv = ymn;
                yMv = yMn;
                xcv = xcn;
                xcv = xcn;
                objeto.getPuntos().clear();
                objeto.getPuntos().addAll(puntosN);
            }
            grados += giroRotacion;
        }

        objeto.setV1x(xmv);
        objeto.setV1y(ymv);
        objeto.setV2x(xMv);
        objeto.setV2y(yMv);

        return objeto;
    }

    /**
     * @deprecated no va?
     * @param puntos
     * @return
     */
    private double areaObjeto(List<Punto> puntos) {
        double area = 0;
        Punto pto1;
        Punto pto2;

        for (int i = 0; i < puntos.size() - 1; i++) {
            pto1 = puntos.get(i);
            pto2 = puntos.get(i + 1);
            area += pto1.getX() * pto2.getY() - pto1.getY() * pto2.getX();
        }

        pto1 = puntos.get(0);
        pto2 = puntos.get(puntos.size() - 1);
        area += pto1.getX() * pto2.getY() - pto1.getY() * pto2.getX();

        return 0.5 * Math.abs(area);
    }

    /**
     * @deprecated no va?
     * @param nuevo
     * @return
     */
    private ArrayList<Punto> rotar180(Objeto nuevo) {
        float xcv = (nuevo.getV2x() - nuevo.getV1x()) / 2;
        float ycv = (nuevo.getV2y() - nuevo.getV1y()) / 2;
        ArrayList<Punto> puntosN = new ArrayList<Punto>();

        for (Iterator<Punto> it = nuevo.getPuntos().iterator(); it.hasNext();) {
            Punto pto = it.next();
            Punto ptoN = new Punto();
            ptoN.setX(xcv + (pto.getX() - xcv) * Math.cos(180) - (pto.getY() - ycv) * Math.sin(180));
            ptoN.setY(ycv + (pto.getX() - xcv) * Math.sin(180) + (pto.getY() - ycv) * Math.cos(180));
            puntosN.add(ptoN);
        }

        return puntosN;
    }
}
